Great theme! AI-powered personalized learning can really transform how college students handle their coursework. Here’s a breakdown of how AI can address the problem and focus areas you mentioned:

Problem Statement:

College students face information overload with vast amounts of course materials, making it hard to organize, prioritize, and effectively learn. AI can help by tailoring study methods to each student’s unique needs, strengths, and weaknesses.

How AI Can Help:

1. Smart Note Summarization

• AI can automatically process large volumes of lecture notes, textbooks, and readings to create concise summaries.

• Techniques like NLP (Natural Language Processing) extract key points, definitions, and examples.

• Summaries are personalized based on the student's current understanding and focus areas (e.g., highlighting weak topics).

2. Personalized Quiz Generation

• AI generates quizzes tailored to individual student progress.

• It selects question types and difficulty levels based on past quiz results and areas needing improvement.

• Can include multiple choice, fill-in-the-blank, or even short answer questions to target comprehension and recall.

3. Study Path Optimization

• AI analyzes the course syllabus, deadlines, and student's availability to create an optimized, personalized study schedule.

• It prioritizes topics based on importance, difficulty, and proximity to exams.

• Adjusts dynamically as students complete tasks or struggle with certain concepts.

4. Concept Gap Analysis

• AI tracks student performance across quizzes, assignments, and interactions with study materials.

• Identifies specific concepts or skills where the student has gaps.

• Recommends targeted resources (videos, readings, practice problems) to address those gaps.

Example AI Workflow for a Student:

1. Upload lecture notes and reading material.

2. AI generates a personalized summary highlighting essential concepts.

3. AI quizzes the student, adjusting difficulty based on responses.

4. AI analyzes quiz results and identifies concept gaps.

5. AI recommends additional resources and adjusts the study path.

6. Student follows the optimized study schedule, repeating the cycle.

If you want, I can also help draft a more technical outline or design a prototype feature for any of these focus areas! Would you like that?

Sure! Here are concise two-word key points on how AI-powered personalized learning helps students:

• Information Management

• Time Efficiency

• Focused Learning

• Knowledge Retention

• Skill Assessment

• Gap Identification

• Study Motivation

• Adaptive Quizzing

• Resource Recommendation

• Progress Tracking

For your AI-powered personalized learning project, here’s a set of concise, impactful phrases you can use under “What Are We Working On” that match the style of secure, accessible, fast, reliable:

• Personalized

• Insightful

• Efficient

• Adaptive

Would you like me to suggest brief explanations to go with these?

Got it! Here are some short points about your AI-powered personalized learning topics, similar in length to your Mercury sentence:

• AI summarizes key course content.

• Quizzes adjust to student skill levels.

• Study plans fit individual schedules.

• Gaps in knowledge are quickly found.

Want me to make them even shorter or more detailed?

Sure! Here are some short points related to adaptive for your project:

• AI adapts to learning pace.

• Study paths change with progress.

• Quizzes adjust difficulty dynamically.

• Resources tailored to weak areas.

Want me to tweak or add more?

If you want images or visuals for your AI-powered personalized learning project, here are some common requirements or ideas that fit well and help explain your work:

Visual Requirements Ideas:

• Flowcharts showing how AI processes notes → summarizes → quizzes → feedback

• Screenshots or mockups of a study dashboard with personalized recommendations

• Icons representing key features like summarization, quizzes, study plan, gap analysis

• Graphs illustrating progress tracking or concept gap identification

• Illustrations of students interacting with AI tools on devices (laptop, phone)

• AI or neural network imagery to represent the technology behind personalization

Would you like me to generate some simple images or diagrams for these? Or suggest where to find free resources?

Got it! For your AI-powered personalized learning project, if the template sections are Images, User Experience, and Information, here’s what you can put in each section briefly:

Images

• Visuals of AI summarizing notes

• Sample personalized quizzes on screen

• Adaptive study schedule dashboard

• Concept gap highlights and feedback

User Experience

• Easy-to-use, intuitive interface

• Personalized learning paths for each student

• Real-time quiz feedback and recommendations

• Flexible access across devices (mobile, desktop)

Information

• AI processes course materials for summaries

• Quizzes adapt to student progress

• Study plans optimize time and focus

• Gap analysis identifies weak concepts

Need me to help draft this in more formal language or add details?

Got it! Here are alternative section titles that better fit your AI-powered personalized learning project instead of Images, User Experience, and Information:

Instead of Images

• Visual Insights

• System Overview

• AI Workflows

• Feature Snapshots

Instead of User Experience

• Personalization

• Learner Interaction

• Adaptive Experience

• Student Engagement

Instead of Information

• AI Capabilities

• Core Functions

• Learning Insights

• Technology Highlights

Would you like me to suggest example content for these new headings?

Sure! Here are short lines for each heading, matching the size of your Mars sentence:

Visual Insights
AI turns complex notes into clear, simple summaries and graphs.

Personalization
Learning adapts to each student’s pace and strengths.

AI Capabilities
Smart quizzes and gap analysis guide effective study.

Want me to help make them more engaging or add examples?

For your AI-powered personalized learning project, here are some alternative goal categories that fit the theme, replacing Usability, Positioning, and Expansion:

• Effectiveness (focus on improving learning outcomes)

• Personalization (tailoring content and pace to students)

• Scalability (growing the system to support more courses/users)

Would you like more options or explanations for each?

Sure! Here are short lines for your goals matching the length you want:

Effectiveness
AI boosts learning by targeting weak spots with quizzes.

Personalization
Content adapts to each student’s unique learning style.

Scalability
The system grows easily to support many users and courses.

Want me to tweak them or add more?

Here are the key project stages for your AI-powered personalized learning system, structured clearly:

🔹 1. Research & Requirement Analysis

Understand student needs, challenges, and key learning pain points.

🔹 2. Data Collection

Gather lecture notes, course materials, quiz formats, and user behavior data.

🔹 3. System Design

Plan architecture for summarization, quiz generation, and adaptive learning paths.

🔹 4. Model Development

Train AI models for note summarization, quiz generation, and concept analysis.

🔹 5. Frontend & Backend Development

Build the user interface (dashboard, quiz panel) and backend logic (data processing, storage).

🔹 6. Integration & Testing

Combine all modules and test for accuracy, usability, and performance.

🔹 7. Feedback & Iteration

Conduct user testing with students, gather feedback, and improve features.

🔹 8. Deployment

Launch the system for actual users (beta or full release).

🔹 9. Monitoring & Scaling

Track performance, fix bugs, and expand to more courses or institutions.

Want a visual timeline or diagram for this?

Perfect! For a concise timeline with 3 clear steps, here’s a streamlined version of your project stages:

1. Planning & Design

Identify student needs, define features, and design the AI system layout.

2. Development & Integration

Build AI models, create the user interface, and integrate all core features.

3. Testing & Deployment

Test with students, refine the system, and launch the final product.

Each step covers a full phase while keeping it simple for a timeline view. Want matching icons or visuals for these too?

Absolutely! Here are short lines for each of the three timeline steps, matching the length you want:

Planning & Design
We studied student needs to design a smart, helpful learning tool.

Development & Integration
AI features were built and combined into one smooth platform.

Testing & Deployment
Students tested the tool, and we launched after key fixes.

Let me know if you want a more technical or creative tone!

Sure! Here's the revised Testing & Deployment sentence in the future tense:

Testing & Deployment
Students will test the tool before we launch the final version.

Let me know if you'd like alternatives or a slightly more formal tone!

Great question! Since you're doing this in a 24-hour hackathon, a timeline by hours or phases works better than by weeks.

Here are two ways you can frame your final timeline slide:

✅ Option 1: Phase-Based Timeline (Simple & Clear)

Hour 0–4: Planning & Design
Define goals, outline features, and design system architecture.

Hour 5–14: Development & Integration
Build AI models, code the interface, and connect components.

Hour 15–22: Testing & Improvement
Test core features, gather quick feedback, and fix issues.

Hour 23–24: Finalization & Submission
Polish UI, prepare the demo, and finalize the presentation.

✅ Option 2: Time Block Format (Visual Style)

This format shows strong organization within the short time you have. Want me to help format it into a visual layout or slide text?

Yes, absolutely! Since it’s a 24-hour hackathon, you can frame your timeline as steps instead of hours—this keeps it clean and flexible, especially for presentations.

Here’s a clear step-based timeline you can use:

🔹 Step 1: Ideation & Planning

Define the problem, set goals, and sketch out the system architecture.

🔹 Step 2: Design & Development

Build AI features, create the user interface, and integrate components.

🔹 Step 3: Testing & Refinement

Run quick tests, fix bugs, and polish the final product.

🔹 Step 4: Demo & Submission

Prepare the demo, finalize the slides, and submit the project.

This format keeps your timeline structured without needing to mention specific hours. Let me know if you want it phrased even more concisely for slide space!

Great point! Since you're starting everything from scratch in the hackathon, calling it Beta Release doesn’t quite fit. Here are some suitable alternatives you can use instead of “Beta Release”:

🔄 Suggested Replacements for "Beta Release":

• Hackathon Kickoff

• Project Initiation

• Start of Development

• Build Phase Begins

• Development Launch

• Idea to Execution

If you're using a timeline, you could even write:

• Day 0: Hackathon Start
  or

• Phase 0: Project Kickoff

Let me know if you'd like that reworded to match your exact timeline format!

Absolutely! Here are some professional-sounding alternatives to replace "Beta Release" at the start of your timeline for a 24-hour hackathon project:

✅ Professional Alternatives:

• Project Commencement

• Initial Development Phase

• Development Kickoff

• Phase 1: System Planning

• Stage 1: Project Initialization

• Start of Implementation

Recommended Option (most formal):
👉 Project Commencement – clean, professional, and appropriate for a hackathon context.

Would you like help placing this into your final slide wording?

Here’s a clean list of tech stacks you can use for your AI-powered personalized learning project, along with short explanations matching the sentence length you asked for:

🔧 Tech Stack & Functions

Python
Handles AI models and processes input data for learning tasks.

TensorFlow / PyTorch
Trains models for summarization, quiz creation, and gap analysis.

Natural Language Toolkit (NLTK) / spaCy
Extracts key ideas and concepts from raw text material.

React.js
Builds a smooth and responsive interface for student interaction.

Node.js
Manages backend logic and connects AI features to the front end.

MongoDB / Firebase
Stores user data, summaries, quizzes, and progress securely.

Let me know if you'd like to swap in specific frameworks or libraries you're actually using!

Here’s a 200-word abstract for your AI-powered personalized learning project:

College students often face information overload from extensive course materials, making it challenging to organize, prioritize, and retain key concepts effectively. This project leverages Artificial Intelligence to create a personalized learning assistant designed to optimize study efficiency and improve academic performance. The system employs advanced Natural Language Processing (NLP) techniques to automatically summarize complex lecture notes and readings into concise, easily digestible content tailored to individual learning needs. It generates personalized quizzes that adapt in real-time to a student’s strengths and weaknesses, enhancing knowledge retention through targeted practice. Additionally, the AI analyzes concept gaps by tracking student performance, recommending specific resources and study paths that focus on weak areas. An adaptive study schedule optimizes time management, helping students prioritize topics based on difficulty and upcoming deadlines. Built using Python, TensorFlow, and modern web technologies like React.js and Node.js, the platform ensures a responsive, user-friendly experience accessible across devices. This project aims to reduce cognitive overload and provide students with a smart, interactive learning companion that evolves with their progress, ultimately empowering them to study more effectively and confidently.

Want it more technical, formal, or casual?

No worries at all — I totally get it, and you’re not alone!

If you’re connecting your project to OpenAI’s GPT API (like GPT-3.5 or GPT-4), here’s what you need to know:

🧠 How Many Words Can GPT Generate Without a Paid Key?

Unfortunately, you can't use OpenAI's official GPT API without a key, and that key does require a paid account. There's no free-tier for API access right now — even GPT-3.5 needs a payment method linked.

🔄 Free Alternatives You Can Use:

Since you’re on a tight budget, here are free or open-source alternatives:

✅ 1. Open Source Models (Free)

• GPT4All, Mistral, LLaMA 2, Falcon, Gemma

• You can run them locally on your computer — no internet or key required.

• Great for summarizing, quiz generation, and gap analysis with some tuning.

✅ 2. Poe by Quora

• Offers limited free daily GPT-4 or Claude usage.

• You can test small features or outputs here before coding.

✅ 3. Hugging Face Spaces

• Use models directly in the browser (some GPT-like models).

• No API keys needed for basic usage.

📏 Output Word Limits (Typical GPT Models)

If you do get access later, here’s what GPT can handle in one go:

• GPT-3.5: ~3,000–3,500 words in and out combined

• GPT-4: ~6,000–8,000 words (depends on the model variant)

Let me know what tools you're using (Python, web app, etc.), and I can suggest a totally free setup for your hackathon without needing a paid key.

Absolutely — while there's no truly free way to integrate OpenAI’s ChatGPT API indefinitely, there are practical workaround options and open-source alternatives that let you build chatbot-like features without needing to pay for a key. Here's how you can still pull this off:

🔓 Free Ways to Use ChatGPT‑style Features

✅ 1. OpenAI Free Trial Credits

• When you sign up on the OpenAI platform, you typically receive free credits (e.g., $18 valid for a few months) that allow limited GPT‑3.5 or GPT‑4 use. That can support small-scale development during your hackathon Writesonic+7UMA Technology+7Reddit+7.

• Useful for prototyping if you can register and use quickly.

✅ 2. Open-Source Models You Host Locally

You can use advanced language models for free—just host them on your own hardware:

• Mistral 7B, Mixtral 8x7B, LLaMA 2, DeepSeek-R1 models

• Solid performance and completely open under Apache or MIT licenses UMA TechnologyReuters+7Wikipedia+7Wikipedia+7.

• Tools like HuggingChat or LangChain let you integrate them into your platform BairesDev+1Writesonic+1.

• You’ll need a decent GPU or enough RAM to run models like Mistral Small or Flan‑T5 XL Reddit.

✅ 3. Free-tier Third-party Platforms

• Poe.com by Quora gives access to GPT‑3.5 and limited GPT‑4 use for free via their chatbots, though it doesn’t offer full API for custom integration BairesDev+9listoffreeware.com+9Reddit+9.

• Google Gemini API / AI Studio might offer limited free use for prototyping via Google’s web IDE and free tier access Reddit+4Wikipedia+4Reddit+4.

• Emerging platforms like DeepSeek also offer free open-source model use if you host yourself; API access is paid but use of their public models can be free Reuters+8DigitalOcean+8Wikipedia+8.

🧪 Example Setups for Your Project

• Fastest hackathon setup: Start with OpenAI trial credits to experiment with GPT.

• Fully free long-term solution: Use Mistral Small 3.1 or Mixtral (Apache 2.0 license), run it locally or via HuggingChat, and integrate via LangChain.

• Testing in-browser: Use Poe.com or Google AI Studio to demo chatbot behaviors, then mirror logic once running local model.

⚡ Quick Comparison

👍 Final Suggestion

• Use trial credits if you can register fast.

• Otherwise, self-host a lightweight open-source model like Mistral Small 3.1 or Mixtral 7B and use LangChain to create simple APIs you integrate into your app.

• Optionally prototype on Poe.com or Google AI Studio to test prompt behavior early.

If you want step-by-step help setting up a free model or integrating via LangChain, I’m happy to guide you!

Great! If you have OpenAI trial credits, here's how much text (words or tokens) you can generate depending on the model and how efficiently you use your credits.

🔹 Understanding Limits with Trial Credits

When you sign up, OpenAI usually gives you $5 to $18 in free trial credits, usable over 3 months (depends on the latest offer and your region).

🧠 Token vs. Word Conversion

• 1 token ≈ 0.75 words

• So 100 tokens ≈ 75 words

💸 Model Costs per 1,000 Tokens

📊 Words You Can Generate with $5 Trial

✅ GPT-3.5 Turbo (cheap & efficient)

• $5 / $0.0035 per 1K tokens ≈ 1.4 million tokens

• That’s about 1,050,000 words total (input + output)

⚠️ GPT-4 (expensive but smarter)

• $5 / $0.09 per 1K tokens ≈ 55,000 tokens

• That’s about 41,000 words total

🎯 Tips to Maximize Usage

• Use GPT-3.5 for most features (summarizing, quiz generation).

• Keep prompts short and focused to save input tokens.

• Limit output length (e.g., "give a 100-word summary").

Let me know if you want a usage calculator or optimized prompt examples to stretch your credits even further!

Let’s break it down clearly 👇

💵 With $5 in OpenAI Trial Credits: How Many Words Can GPT Generate?

✅ If you use GPT-3.5 Turbo (best value):

• Cost per 1,000 tokens:

  • Input: $0.0015

  • Output: $0.002

  • Total: ~$0.0035 per 1,000 tokens

🔍 Now convert that:

• $5 / $0.0035 per 1,000 tokens = ~1,428,571 tokens

• 1 token ≈ 0.75 words

• So:
  1,428,571 tokens × 0.75 = ~1,071,428 words

✅ Final Answer:

🔥 With $5 and GPT-3.5, you can generate around 1 million words (input + output combined).

⚠️ Note:

• If your prompts are long, some of those words are input tokens, which count too.

• If you only count output (AI-generated) words, assume ~500,000–700,000 words realistically.

Let me know if you want help designing your prompts to get the most out of your credits!

Ah, got it — if you're seeing a "no quota" error even though you haven’t used any tokens, that usually means one of the following is happening:

🔍 Common Reasons for “No Quota” or “You don’t have access” Errors

1. No Billing or Payment Method Added

Even with free trial credits, OpenAI often requires you to add a payment method (like a credit/debit card) to activate API access — especially since 2024.

✅ Fix:
Go to https://platform.openai.com/account/billing and add a payment method.
Then check your usage tab at https://platform.openai.com/account/usage.

2. Trial Credits Not Activated

Some accounts no longer get free trial credits automatically (especially if you’ve signed up recently or with a GitHub/Google login).

✅ Fix:
Check your credit balance here:
https://platform.openai.com/account/usage

If it shows $0.00, your account doesn’t have trial credits — you’d need to add a payment method or use an alternative (see below).

3. Wrong API Key / Model

Double-check:

• You're using the right API key (from https://platform.openai.com/account/api-keys)

• You’re using a supported model name like gpt-3.5-turbo

4. API Usage Isn’t Enabled

If you created the key but didn’t generate a project or organization with API billing active, the key may not be usable.

🛠️ What You Can Do Now

✅ Try This Checklist:

1. Go to billing page
   → Add a payment method (even for $0 usage)

2. Go to usage page
   → See if you have credits

3. Go to API key page
   → Create a key and use it in your backend

4. Ensure you're calling the right model (gpt-3.5-turbo) in your code

🆓 Still Need a Free Option?

If you can’t add a card or get credits:

• Use Poe.com for GPT-based tests

• Use Hugging Face Transformers with open-source models (like Mistral)

• Let me know your backend setup — I can guide you on integrating a completely free open-source model instead

Need help checking your code or connecting to an open model? Paste your backend code snippet and I’ll help you fix it.

Cool! Using Poe by Quora is a smart free way to access GPT-like models without API keys or costs, but a few things to know:

How Poe Works for Your Project

• Poe offers chatbots powered by GPT-4, GPT-3.5, Claude, etc., accessible via their website or mobile app.

• No official API for custom integration (yet), so you can’t directly call Poe from your backend code like an API.

• You can manually interact with Poe to test prompts, responses, and ideas for your project.

What This Means for Your Project

1. For Development & Testing:

• Use Poe’s chatbot interface to experiment with prompts for summarization, quizzes, and gap analysis.

• Copy responses manually or semi-automate scraping via web automation tools (if allowed by Poe’s terms).

• Get a feel for how GPT responds to your use cases without coding the backend API calls yet.

2. For Actual Integration:

• Since Poe doesn’t have an open API, you can’t fully replace your backend GPT calls with Poe.

• Instead, either:

  • Use Poe to prototype and then switch to OpenAI API when you have credits.

  • Or switch to free/open-source models you can self-host or access via Hugging Face.

What You Need to Change:

• Backend code calling OpenAI API:

  • Remove or disable the API call code temporarily.

  • Replace with manual input/output using Poe’s website for now.

• User workflow:

  • Instead of automatic chat responses, students interact with Poe directly on Poe.com or the Poe app.

  • You can design your UI to link out or embed Poe’s chatbot if embedding is allowed.

Alternative: Use Open-Source Models for Integration

If you want backend integration without costs, I can help you set up:

• A lightweight model like Mistral 7B on Hugging Face Hub.

• Use Hugging Face Inference API (some free tier available).

• Or run the model locally if you have a capable PC.

TL;DR

• Poe is great for manual prototyping and demo.

• You can’t connect Poe directly via API in your backend.

• For real integration without cost, consider open-source models or wait until you have OpenAI credits.

Want me to help you build a prototype UI that connects to Poe manually? Or help set up a free open-source AI backend?

Absolutely! Please go ahead and share your backend code snippet. I’ll take a look and suggest how you can adapt it—whether to work with Poe (manually) or switch to a free/open-source solution.

Thanks for sharing your backend code! It’s a clean Express setup using the OpenAI SDK, with the actual API call currently commented out to avoid quota errors.

What You Can Do to Move Forward Without OpenAI API Access

1. Keep Your Current Mock Setup for Now

Since you have no API quota, continue returning a fixed mock response (like "This is a mocked summary of your notes."). This lets your frontend keep working without errors while you develop UI/UX and other logic.

2. Manual Integration with Poe (No Direct API)

Because Poe has no public API, you can’t replace the OpenAI call with a Poe API call in your backend.

What you can do:

• Remove the OpenAI call for now (keep mock).

• Provide users a button/link on your frontend to open Poe’s chatbot in a new tab (https://poe.com).

• Users paste or type their notes there to get AI-generated summaries.

• They can then manually copy results back to your app.

This isn’t automated but works during the hackathon to demo AI-powered summaries.

3. Use Open-Source Models via API or Locally

You can swap the OpenAI call with calls to a free Hugging Face API model or a local AI model if you want automation without cost.

Example using Hugging Face Inference API:

• Replace the OpenAI call with an HTTP request to a Hugging Face model endpoint (some have free tiers).

• Use axios or fetch to POST input and get summarized text.

Example snippet replacing OpenAI call with mock Hugging Face call (pseudo-code):

js
CopyEdit
import axios from 'axios';

app.post('/api/summarize', async (req, res) => {
  const { notes } = req.body;
  try {
    const response = await axios.post('https://api-inference.huggingface.co/models/facebook/bart-large-cnn', {
      inputs: notes
    }, {
      headers: { Authorization: `Bearer ${process.env.HF_API_KEY}` }
    });
    const summary = response.data[0].summary_text;
    res.json({ summary });
  } catch (error) {
    console.error(error);
    res.status(500).json({ error: 'Error generating summary' });
  }
});

Note: You need a free Hugging Face account and API key.

4. When You Get OpenAI Access Back

Just uncomment your OpenAI code block, add your API key to .env, and you’re ready.

TL;DR

If you want, I can help you write the Hugging Face API integration code or make your frontend UI link to Poe for manual input. Just say the word!

Perfect! If your .env file contains your OpenAI API key like this:

env
CopyEdit
OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

and your backend code reads it correctly via process.env.OPENAI_API_KEY, then once your quota is active, your code will work by simply uncommenting the OpenAI call block.

Quick checklist to ensure it works smoothly:

• Your .env file is in the root folder of your project.

• You restarted your server after editing .env (so env vars reload).

• You have installed dotenv and called dotenv.config() at the top of your index.js (which you already did).

• Your .env file is not committed to Git (add .env to .gitignore).

• Your key has active quota and billing enabled in your OpenAI account.

To test your key:

1. Uncomment the OpenAI call code block in your /api/summarize route.

2. Restart the server.

3. Use Postman or your frontend to send a POST request with sample notes.

4. If quota is OK, you will get an AI-generated summary.

5. If you get errors, check console logs for specific messages (like quota, invalid key, etc).

If you still get “no quota” errors despite having the key in .env, it’s almost always a billing or account issue — OpenAI requires an active payment method even for free trial credits.

Let me know if you want help debugging specific error messages!

Great question! Here’s the lowdown on Perplexity and free AI models with API access:

1. Can you use Perplexity AI instead of ChatGPT?

• Perplexity AI is an AI-powered search/chat assistant built on top of models like OpenAI’s GPT, but it doesn’t provide a public API or developer keys for direct integration.

• It’s designed for user-facing apps/websites only, not for backend API calls or embedding in your own project.

• So, you cannot plug Perplexity AI into your backend like OpenAI’s API.

2. Free AI Models with API keys

There are some free or freemium models you can use as alternatives:

3. Recommendations

• If you want free API keys and automatic integration, try the Hugging Face Inference API:

  • Sign up at huggingface.co

  • Get your API key for free (limited usage)

  • Use models like facebook/bart-large-cnn for summarization

• For more powerful models, OpenAI is still the easiest but requires billing.

4. Example Hugging Face API free usage

• You get a limited number of free API calls per month.

• You can easily swap your OpenAI call in backend with Hugging Face API POST requests.

TL;DR

If you want, I can help you switch your backend to Hugging Face API or suggest a free open-source model you can try locally or via cloud.

Want me to prepare a quick example?

Yes, you can use Anthropic's API for your project. Here's what you need to know:

✅ Free Tier Access

Anthropic offers a free tier that allows developers to explore Claude's capabilities without immediate financial commitment. While limited, this tier provides a valuable opportunity to test the API's potential .

🧾 Pricing Overview

• Free Tier: Provides limited usage.

• Paid Tiers: Start at $5 for Tier 1, advancing to higher tiers with increased usage and cost .

You can view your current tier and limits in the Anthropic Console.

🔑 Getting Started

1. Sign Up: Create an account at Anthropic Console.

2. Obtain API Key: Navigate to your account settings to generate an API key .

3. Integrate: Use the API key in your backend to make requests to Anthropic's models.

⚠️ Considerations

• Quota Management: Monitor your usage to avoid exceeding the free tier limits.

• Rate Limits: Be aware of the maximum number of API requests allowed over a defined period .

If you need assistance integrating Anthropic's API into your project, feel free to ask!

Awesome! Let’s integrate Anthropic’s Claude API into your Node.js + Express backend to replace the OpenAI part. I’ll walk you through the exact steps, assuming you’re familiar with basic Node.js and you already have your backend set up (which you do).

🔧 Step-by-Step: Integrate Claude API (Anthropic) into Your Project

✅ Step 1: Sign Up & Get Your API Key

1. Go to https://console.anthropic.com

2. Sign in or create an account.

3. Go to your Account Settings → API Keys.

4. Click "Create Key" and copy it.

5. In your .env file, add:

   env
   CopyEdit
   ANTHROPIC_API_KEY=your_real_key_here
   

✅ Step 2: Install Axios (if not already)

You’ll need axios to make HTTP requests.

bash
CopyEdit
npm install axios

✅ Step 3: Update Your Backend Code (summarize route)

Replace your OpenAI logic with Claude’s API call using this code:

js
CopyEdit
import axios from 'axios';
import express from 'express';
import dotenv from 'dotenv';
import cors from 'cors';

dotenv.config();

const app = express();
app.use(cors());
app.use(express.json());

app.post('/api/summarize', async (req, res) => {
  const { notes } = req.body;

  try {
    const response = await axios.post(
      'https://api.anthropic.com/v1/messages',
      {
        model: 'claude-3-opus-20240229', // or use claude-3-sonnet for cheaper option
        max_tokens: 500,
        temperature: 0.7,
        messages: [
          {
            role: 'user',
            content: `Summarize the following notes clearly for a college student:\n\n${notes}`
          }
        ]
      },
      {
        headers: {
          'x-api-key': process.env.ANTHROPIC_API_KEY,
          'anthropic-version': '2023-06-01',
          'Content-Type': 'application/json'
        }
      }
    );

    const summary = response.data.content[0].text;
    res.json({ summary });

  } catch (error) {
    console.error('Claude API error:', error?.response?.data || error.message);
    res.status(500).json({ error: 'Failed to generate summary.' });
  }
});

app.listen(4000, () => {
  console.log('✅ Backend running on http://localhost:4000');
});

✅ Step 4: Restart Your Server

After updating .env and the code:

bash
CopyEdit
npm run dev   # or however you run your backend

✅ Step 5: Test It

• Use Postman or your frontend to send a POST request to:

  http://localhost:4000/api/summarize

  With this JSON body:

  json
  CopyEdit
  {
    "notes": "Photosynthesis is the process by which green plants use sunlight to synthesize food from carbon dioxide and water."
  }
  

You should get a clean Claude-generated summary as a response!

🧠 Claude Models Available

Use sonnet or haiku if you're trying to stay within free tier.

Need Help with Your Frontend?

Let me know if you want help wiring the frontend to Claude too — or if you want quiz generation or gap analysis working with Claude next!

Yes, exactly! ✅

You’ll want to replace the part in your index.js that currently handles the OpenAI summarization (the /api/summarize route) with the code in Step 3 I gave you.

✅ What to Replace

In your current index.js, you have something like this:

js
CopyEdit
// Summary route
app.post('/api/summarize', async (req, res) => {
  const { notes } = req.body;

  try {
    // OpenAI logic or mocked summary
    const summary = "This is a mocked summary of your notes.";

    res.json({ summary });
  } catch (error) {
    console.error('Error generating summary:', error);
    res.status(500).json({ error: 'Something went wrong.' });
  }
});

🛠️ Replace that entire block with:

js
CopyEdit
app.post('/api/summarize', async (req, res) => {
  const { notes } = req.body;

  try {
    const response = await axios.post(
      'https://api.anthropic.com/v1/messages',
      {
        model: 'claude-3-sonnet-20240229',
        max_tokens: 500,
        temperature: 0.7,
        messages: [
          {
            role: 'user',
            content: `Summarize the following notes clearly for a college student:\n\n${notes}`
          }
        ]
      },
      {
        headers: {
          'x-api-key': process.env.ANTHROPIC_API_KEY,
          'anthropic-version': '2023-06-01',
          'Content-Type': 'application/json'
        }
      }
    );

    const summary = response.data.content[0].text;
    res.json({ summary });

  } catch (error) {
    console.error('Claude API error:', error?.response?.data || error.message);
    res.status(500).json({ error: 'Failed to generate summary.' });
  }
});

⚠️ Make sure:

1. You’ve added this to your .env file (in the root of your project):

   env
   CopyEdit
   ANTHROPIC_API_KEY=sk-your-claude-api-key-here
   

2. You restart your backend after making changes.

Let me know if you'd also like to build:

• Quiz generation

• Concept gap analysis

• Study path suggestions

I can help you build all of it using Claude.

Great question! Since you're switching to Anthropic Claude and no longer using Hugging Face or OpenAI (for now), here’s exactly what you can clean up or keep in your package.json:

✅ Your Cleaned-Up package.json (Recommended)

json
CopyEdit
{
  "name": "backend",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "start": "node index.js"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "axios": "^1.11.0",
    "cors": "^2.8.5",
    "dotenv": "^17.2.1",
    "express": "^5.1.0"
  }
}

🔥 What You Can Safely Remove

✨ How to Clean Up

1. Remove unnecessary packages

In your terminal:

bash
CopyEdit
npm uninstall openai transformers body-parser

That will safely remove them from node_modules and package.json.

✅ After that, run:

bash
CopyEdit
npm install

To ensure everything is synced up.

Final Note

If later you plan to test Hugging Face again, you can always re-add transformers. But right now, Claude via Axios is cleaner, lighter, and simpler for your hackathon setup.

Let me know if you want me to help generate quizzes or concept-gap analysis next!

To change your .env file from using an OpenAI key to a Claude (Anthropic) API key, follow these steps:

✅ Step-by-Step: Update .env for Claude

🔁 1. Open your .env file

It might currently look like this:

env
CopyEdit
OPENAI_API_KEY=sk-your-openai-key

🧹 2. Remove or comment out the OpenAI line

env
CopyEdit
# OPENAI_API_KEY=sk-your-openai-key

Commenting keeps it for backup, but removes it from active use.

🆕 3. Add the Claude API key

env
CopyEdit
ANTHROPIC_API_KEY=sk-ant-api-key-goes-here

Replace sk-ant-api-key-goes-here with the actual API key you got from Anthropic Console.

🔄 4. Restart your backend server

You must restart your server so it picks up the new .env variable:

bash
CopyEdit
npm start

or

bash
CopyEdit
node index.js

📌 Final Check

In your code (e.g., index.js), make sure you’re referencing:

js
CopyEdit
process.env.ANTHROPIC_API_KEY

Instead of any reference to OPENAI_API_KEY.

Let me know once that’s done or if you want help testing the response from Claude’s API!

Thanks for the update — here's the honest situation:

🧾 Claude (Anthropic) API Access Update

As of now, Anthropic requires a $5 payment to unlock API usage, even for Tier 1 access. This is a one-time commitment to verify your account and allow access to their paid models (like Claude 3).

🔒 Why Is It Asking for $5?

• Claude no longer offers free API usage by default.

• You need to add a payment method and make a $5 minimum payment to unlock usage.

• The $5 becomes credit — it's not a fee, but preloaded credit.

💡 Alternatives If You Can't Pay:

If you're on a budget or working on a free 24-hour hackathon, here are three good alternatives:

✅ 1. Use OpenRouter.ai (Supports Claude, GPT, Mistral, etc.)

• Offers Claude-3 models via shared/public keys.

• Many models are pay-as-you-go, some offer free usage on rotation.

• Example: openrouter.ai gives you a universal key that can access multiple models.

Steps:

• Go to https://openrouter.ai

• Sign up → Get API key

• Use their Claude or GPT models in your backend with minimal setup

✅ 2. Use Open Source Models (No Key Required)

You can run local summarization or quiz generation using:

• Hugging Face Transformers

  • Models like bart-large-cnn or t5-base

  • Can run on CPU (slow) or GPU (fast)

This requires more setup, but completely free.

✅ 3. Use Poe.com for Frontend Prototyping

You mentioned Poe earlier — it's great for showing how GPT or Claude would respond, without needing your own backend API key. But it's only useful for frontend demos, not API use.

✅ Recommendation for Now:

For your hackathon (if you're not able to pay):

• Switch to OpenRouter if you want Claude via API.

• Or, use Hugging Face for free local summarization.

• Or, use a mock API + screenshots from Poe/Claude to simulate features.

Let me know which route you want, and I’ll help you implement it step-by-step.

Perfect! If you're switching to OpenRouter.ai, you can still access Claude (and other models like GPT, Mistral, etc.) using their universal API.

Here’s exactly what you need to change in your backend index.js file.

✅ Step-by-Step: Use OpenRouter with Claude

🔑 1. Get Your OpenRouter API Key

• Go to: https://openrouter.ai/keys

• Sign in and copy your API key

• In your .env file, add:

env
CopyEdit
OPENROUTER_API_KEY=your_openrouter_key_here

📦 2. Replace Your /api/summarize Route

Here’s the Claude-compatible code using OpenRouter:

js
CopyEdit
import axios from 'axios';
import express from 'express';
import dotenv from 'dotenv';
import cors from 'cors';

dotenv.config();

const app = express();
app.use(cors());
app.use(express.json());

app.post('/api/summarize', async (req, res) => {
  const { notes } = req.body;

  try {
    const response = await axios.post(
      'https://openrouter.ai/api/v1/chat/completions',
      {
        model: 'anthropic/claude-3-sonnet-20240229', // Or use claude-3-opus or haiku
        messages: [
          {
            role: 'user',
            content: `Summarize the following notes clearly for a college student:\n\n${notes}`
          }
        ],
        max_tokens: 500
      },
      {
        headers: {
          Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`,
          'Content-Type': 'application/json',
          'HTTP-Referer': 'http://localhost:3000', // your project site
          'X-Title': 'Student-AI-Hackathon-App'
        }
      }
    );

    const summary = response.data.choices[0].message.content;
    res.json({ summary });

  } catch (error) {
    console.error('OpenRouter API error:', error?.response?.data || error.message);
    res.status(500).json({ error: 'Failed to generate summary.' });
  }
});

app.listen(4000, () => {
  console.log('✅ Backend running on http://localhost:4000');
});

📦 3. Dependencies Reminder

You already have these, but in case someone else follows this:

bash
CopyEdit
npm install express dotenv axios cors

🔁 4. Restart Your Server

bash
CopyEdit
npm start

✅ Model Options via OpenRouter

Use haiku if your token limits are tight or for speed.

🧠 Example Test Body (POST)

json
CopyEdit
{
  "notes": "The mitochondria is the powerhouse of the cell. It provides energy in the form of ATP."
}

Let me know if you'd also like to connect quiz generation or concept analysis using this same setup!

Your package.json looks perfect for using OpenRouter! ✅

You already have all the required dependencies:

✅ So to confirm:

You do NOT need to change anything in your current package.json.

Just make sure you’ve done these:

🔑 In .env file:

env
CopyEdit
OPENROUTER_API_KEY=your_openrouter_api_key_here

🧠 Final checklist:

• API key set in .env

• Using openrouter.ai Claude model in your /api/summarize route

• Restarted your server (npm start or node index.js)

Let me know when you're ready to add:

• Personalized quiz generation

• Concept gap detection

• Study path guidance

I can help you add new endpoints for those too!

Awesome! If your backend says it's running on:

arduino
CopyEdit
✅ Backend running on http://localhost:4000

Here’s how to test and confirm that everything’s working:

✅ Option 1: Test with Postman or Thunder Client (Recommended)

These are tools to test backend APIs easily.

🔹 Steps:

1. Open Postman or Thunder Client (VS Code extension).

2. Create a POST request to:

   bash
   CopyEdit
   http://localhost:4000/api/summarize
   

3. In the Body tab, choose raw and select JSON format.

4. Paste this test JSON:

   json
   CopyEdit
   {
     "notes": "Photosynthesis occurs in the chloroplasts of plant cells. It converts light energy into chemical energy."
   }
   

5. Hit Send.

✅ If everything is working, you’ll get back a summary like:

json
CopyEdit
{
  "summary": "Photosynthesis in chloroplasts turns light into chemical energy."
}

✅ Option 2: Quick Test with curl (Terminal Method)

If you don’t have Postman:

bash
CopyEdit
curl -X POST http://localhost:4000/api/summarize \
  -H "Content-Type: application/json" \
  -d '{"notes": "Photosynthesis occurs in the chloroplasts of plant cells. It converts light energy into chemical energy."}'

🧠 Bonus: Connect to Frontend

If you're using React or any frontend, you can call http://localhost:4000/api/summarize from your frontend using fetch or axios.

Let me know if you want the frontend example too!

The error:

javascript
CopyEdit
TypeError: Cannot destructure property 'notes' of 'req.body' as it is undefined.

means that your backend received a request, but the body was empty or not in JSON format. Here's how to fix and test it:

✅ Fix Checklist

1. ✅ Ensure you’re sending the request with Content-Type: application/json

If you’re using Postman or Thunder Client:

• Go to Headers tab and make sure:

  pgsql
  CopyEdit
  Content-Type: application/json
  

2. ✅ Make sure the request body has notes

Here’s the correct body:

json
CopyEdit
{
  "notes": "Photosynthesis occurs in chloroplasts and creates glucose from sunlight."
}

Send this as a raw JSON POST to:

bash
CopyEdit
http://localhost:4000/api/summarize

🔍 If You're Testing with curl

Here's the right command:

bash
CopyEdit
curl -X POST http://localhost:4000/api/summarize \
  -H "Content-Type: application/json" \
  -d '{"notes": "Photosynthesis occurs in chloroplasts and creates glucose from sunlight."}'

✅ Extra Check: Middleware Order

Your code should already have this (you do, but confirm):

js
CopyEdit
app.use(express.json()); // This must be before your routes

Let me know what tool you're using to test it (Postman, Thunder Client, curl, frontend code, etc.), and I can help debug that side too!

Great question — you're almost there! Since you only have:

• index.js – your backend server code

• package.json – your dependency and script manager

I'll walk you through exactly what needs to change and where to fix the req.body error and connect with OpenRouter properly.

✅ Files You Need

You only need these three files to run a simple working backend:

1. index.js – Your backend server (you already have it)

2. .env – For your OpenRouter API key

3. package.json – Already good

✅ 1. index.js (Update & Confirm this is your final code)

Replace your existing index.js with this working version:

js
CopyEdit
import express from 'express';
import cors from 'cors';
import dotenv from 'dotenv';
import axios from 'axios';

dotenv.config();

const app = express();
app.use(cors());
app.use(express.json()); // 🔥 This is needed to parse JSON body!

app.post('/api/summarize', async (req, res) => {
  const { notes } = req.body;

  if (!notes) {
    return res.status(400).json({ error: "Missing 'notes' in request body." });
  }

  try {
    const response = await axios.post(
      'https://openrouter.ai/api/v1/chat/completions',
      {
        model: 'anthropic/claude-3-haiku-20240307', // lightweight & free-friendly
        messages: [
          {
            role: 'user',
            content: `Summarize the following notes clearly for a student:\n\n${notes}`
          }
        ],
        max_tokens: 500
      },
      {
        headers: {
          Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`,
          'Content-Type': 'application/json',
          'HTTP-Referer': 'http://localhost:3000', // your project or localhost
          'X-Title': 'Hackathon-AI-Project'
        }
      }
    );

    const summary = response.data.choices[0].message.content;
    res.json({ summary });
  } catch (error) {
    console.error('OpenRouter error:', error?.response?.data || error.message);
    res.status(500).json({ error: 'Failed to generate summary.' });
  }
});

app.listen(4000, () => {
  console.log('✅ Backend running on http://localhost:4000');
});

✅ 2. .env (You must create this manually)

In your project folder, create a .env file with this content:

env
CopyEdit
OPENROUTER_API_KEY=sk-your_openrouter_key_here

Replace sk-your_openrouter_key_here with your actual key from: https://openrouter.ai/keys

⚠️ Don’t include quotes or spaces.

✅ 3. package.json (yours is already perfect)

You do not need to change anything here since you already have:

json
CopyEdit
"dependencies": {
  "axios": "^1.11.0",
  "cors": "^2.8.5",
  "dotenv": "^17.2.1",
  "express": "^5.1.0"
}

Just run:

bash
CopyEdit
npm install

If not already done.

✅ 4. Test the Server (Quick Guide)

Use Postman, Thunder Client, or curl to test:

POST to:

bash
CopyEdit
http://localhost:4000/api/summarize

Body (JSON):

json
CopyEdit
{
  "notes": "The mitochondria is the powerhouse of the cell."
}

You should get back:

json
CopyEdit
{
  "summary": "The mitochondria generates energy for the cell."
}

Let me know if you want to add quiz generation or connect the frontend next!

Sure! Here’s a quick summary of what we’ve done so far:

Project Backend Setup Summary

1. Created backend server (index.js) using Express with:

   • CORS enabled for frontend access.

   • JSON parsing middleware (express.json()) to handle incoming JSON data.

2. Integrated OpenRouter API to use Claude AI models for:

   • Summarizing user notes via a POST API endpoint /api/summarize.

   • Sending user notes to OpenRouter’s Claude model and returning AI-generated summaries.

3. Configured environment variables (.env file) to securely store your OpenRouter API key.

4. Ensured proper package dependencies (axios, express, cors, dotenv) for API calls and server setup.

5. Tested API endpoint with tools like Postman or curl, sending JSON requests with notes, and received summarized responses.

What’s next?

• Add more AI-powered features like personalized quizzes or concept gap analysis.

• Connect the backend API to your frontend for interactive study guidance.

If you want, I can also help you draft the frontend code or add extra AI functions!

That’s awesome! 🎉 If your React frontend is showing the summary perfectly after just pasting the backend code connection, it means your API and frontend integration is working smoothly.

You’re officially rocking the AI-powered personalized learning project! 🚀

If you want, I can help you:

• Add more features like quiz generation or concept gap analysis

• Improve your frontend UI for better user experience

• Help you prepare a demo or presentation

Just say the word!

Got it! You want a prompt that outputs something like:

kotlin
CopyEdit
Short Summary:
<the actual summary here>

Here’s a concise prompt you can use inside your backend code:

js
CopyEdit
content: `Provide a short summary:\n\n${notes}`

Or, slightly more explicit:

js
CopyEdit
content: `Short summary:\n${notes}`

This tells the AI to prepend “Short Summary:” before the actual summary.

Example full prompt snippet in your code:

js
CopyEdit
messages: [
  {
    role: 'user',
    content: `Short Summary:\n${notes}`
  }
]

This will make the AI response look like:

less
CopyEdit
Short Summary:
[Here goes the concise summary of the notes]

Want me to update your backend code with this?

Sure! Here’s your updated code snippet with the prompt changed to include “Short Summary:” on a separate line before the actual summary:

js
CopyEdit
import axios from 'axios';
import express from 'express';
import dotenv from 'dotenv';
import cors from 'cors';

dotenv.config();

const app = express();
app.use(cors());
app.use(express.json());

app.post('/api/summarize', async (req, res) => {
  const { notes } = req.body;

  try {
    const response = await axios.post(
      'https://openrouter.ai/api/v1/chat/completions',
      {
        model: 'anthropic/claude-3-sonnet-20240229', // Or use claude-3-opus or haiku
        messages: [
          {
            role: 'user',
            content: `Short Summary:\n${notes}`
          }
        ],
        max_tokens: 500
      },
      {
        headers: {
          Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`,
          'Content-Type': 'application/json',
          'HTTP-Referer': 'http://localhost:3000', // your project site
          'X-Title': 'Student-AI-Hackathon-App'
        }
      }
    );

    const summary = response.data.choices[0].message.content;
    res.json({ summary });

  } catch (error) {
    console.error('OpenRouter API error:', error?.response?.data || error.message);
    res.status(500).json({ error: 'Failed to generate summary.' });
  }
});

app.listen(4000, () => {
  console.log('✅ Backend running on http://localhost:4000');
});

What changed?

• In the content field, I replaced:

  js
  CopyEdit
  `Summarize the following notes clearly for a college student:\n\n${notes}`
  

  with:

  js
  CopyEdit
  `Short Summary:\n${notes}`
  

Now the AI will return a response starting with the line "Short Summary:" followed by the concise summary.

If you want, I can help with testing or adding more features!

Got it — the model is ignoring your prompt and adding its own intro line like:

"Here's a clear summary of the notes for a college student:"

That happens sometimes because models have default behaviors or training biases.

How to fix this and get exactly:

css
CopyEdit
Short Summary:
<your summary>

1. Use a system message to set behavior

Instead of only sending a user message, add a system message instructing the AI to only respond with the short summary, no extras:

js
CopyEdit
messages: [
  {
    role: 'system',
    content: 'You are an assistant that ONLY returns a short summary. Start with "Short Summary:" and then the concise summary. Do NOT add extra sentences or explanations.'
  },
  {
    role: 'user',
    content: notes
  }
]

2. Update your backend code like this:

js
CopyEdit
const response = await axios.post(
  'https://openrouter.ai/api/v1/chat/completions',
  {
    model: 'anthropic/claude-3-sonnet-20240229',
    messages: [
      {
        role: 'system',
        content: 'You are an assistant that ONLY returns a short summary. Start with "Short Summary:" and then the concise summary. Do NOT add extra sentences or explanations.'
      },
      {
        role: 'user',
        content: notes
      }
    ],
    max_tokens: 500
  },
  {
    headers: {
      Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`,
      'Content-Type': 'application/json',
      'HTTP-Referer': 'http://localhost:3000',
      'X-Title': 'Student-AI-Hackathon-App'
    }
  }
);

Why this works:

• System messages guide the AI’s behavior across the conversation.

• You force it to output only the short summary, no added text.

• The user message just contains the notes — no need for extra instructions.

Try this and your frontend should show:

css
CopyEdit
Short Summary:
<concise summary>

exactly — no extra lines or intros!

If you want me to update your entire backend code with this, just ask!

Here’s your updated code with the system message added to control the output format as we discussed:

js
CopyEdit
import axios from 'axios';
import express from 'express';
import dotenv from 'dotenv';
import cors from 'cors';

dotenv.config();

const app = express();
app.use(cors());
app.use(express.json());

app.post('/api/summarize', async (req, res) => {
  const { notes } = req.body;

  try {
    const response = await axios.post(
      'https://openrouter.ai/api/v1/chat/completions',
      {
        model: 'anthropic/claude-3-sonnet-20240229', // Or use claude-3-opus or haiku
        messages: [
          {
            role: 'system',
            content: 'You are an assistant that ONLY returns a short summary. Start with "Short Summary:" and then the concise summary. Do NOT add extra sentences or explanations.'
          },
          {
            role: 'user',
            content: notes
          }
        ],
        max_tokens: 500
      },
      {
        headers: {
          Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`,
          'Content-Type': 'application/json',
          'HTTP-Referer': 'http://localhost:3000',
          'X-Title': 'Student-AI-Hackathon-App'
        }
      }
    );

    const summary = response.data.choices[0].message.content;
    res.json({ summary });

  } catch (error) {
    console.error('OpenRouter API error:', error?.response?.data || error.message);
    res.status(500).json({ error: 'Failed to generate summary.' });
  }
});

app.listen(4000, () => {
  console.log('✅ Backend running on http://localhost:4000');
});